home *** CD-ROM | disk | FTP | other *** search
/ Utilities Professional 1-1500 / Utilities Professional 1-1500 (1994)(WPD)[!].iso / 07511000 / var0784.dms / var0784.adf / Txref / getrefs.c < prev    next >
C/C++ Source or Header  |  1978-01-24  |  7KB  |  267 lines
  1. /*************************************************************************
  2. *    GetRefs.c
  3. *    ( if it looks yucky, set tabstops to 4 )
  4. *
  5. *    Program to extract a section of a file.  Primarily for use with the
  6. *    AREXX referencing macro and TxEd Plus, it can also be used as a 
  7. *    standalone program.
  8. *
  9. *    The program takes 1 command line argument.  If any other number
  10. *    is supplied, the program will exit with an error.  The argument is
  11. *    an ascii string that should match one of the entries in the reference
  12. *    file.  
  13. *    The program writes the extracted text to the file ram:extract.txt
  14. *
  15. *    Programmed by John G. Hardie
  16. *    This program is in the public domain, do with it what you will.
  17. *
  18. *    Compiled under Lattice C v4.0 ( lc -v -b -r getrefs )
  19. *    and Blink 7.2 (blink with lc.lib, amiga.lib, SD SC ND)
  20. **************************************************************************/
  21. #include "libraries/dosextens.h"
  22. #include "stdio.h"
  23. #include "string.h"
  24. #include "ctype.h"
  25.  
  26. /*    Prototypes */
  27. int stringcmp(char *,char *,int *);
  28. void scopynull(char *,char *);
  29.  
  30. struct Process *HereWeAre;
  31.  
  32. main(argc,argv)
  33. int argc;
  34. char **argv;
  35. {
  36.     FILE *infile,*outfile;
  37.     char line[256],searchstr[256],*str,found=0,inch,*sarg[5];
  38.     int leng,locate;
  39.  
  40.     HereWeAre = (struct Process *)FindTask(0);
  41.  
  42.     if (argc != 2)
  43.     {
  44.         puts("Bad command line - you must supply 1 parameter");
  45.         seterror(50);
  46.         Exit(20);    /* bad command line - go away */
  47.     }
  48.     
  49.     /* we search for the reference file in df1:s df0:s and ram:s */
  50.     /* before we give up and go away                             */
  51.     if (!(infile = fopen("df1:s/txed.refs","r")))
  52.     if (!(infile = fopen("df0:s/txed.refs","r")))
  53.     if (!(infile = fopen("ram:s/txed.refs","r")))
  54.     {
  55.         puts("Error - couldn't open input file");
  56.         seterror(51);
  57.         Exit(20);    /* Huh? where the hell is it? */
  58.     }
  59.     
  60.     /* Try to find the keyword string in the file. */
  61.     leng = strlen(argv[1]);
  62.     while (str = fgets(line,256,infile))
  63.     {
  64.         if (stringcmp(str,argv[1],&locate) == leng)
  65.         {
  66.             /* we want an exact match, no partials e.g          */
  67.             /* Open and OpenLibrary don't match in this case */
  68.             if (isspace(*(str+locate+leng)))
  69.             {
  70.                 found++;
  71.                 break;
  72.             }
  73.         }
  74.     }
  75.     
  76.     /* Did we find the string or run out of input file? */
  77.     if (!found)
  78.     {
  79.         puts("Reference String Not Found");
  80.         fclose(infile);
  81.         seterror(52);
  82.         Exit(20);  /* nope, didn't find it <sigh> */
  83.     }
  84.  
  85.     /* get the start, stop, and filename from the input line */
  86.     scopynull(line,searchstr);
  87.     if ((leng = strbpl(sarg,6,searchstr)) != 4)
  88.     {
  89.         puts("Bad Line format in ref file");
  90.         fclose(infile);
  91.         seterror(53);
  92.         Exit(20);
  93.     }
  94.     fclose(infile);
  95.  
  96.     /* Open the search file and commence much looking about */
  97.     if (!(infile = fopen(sarg[2],"r")))
  98.     {
  99.         puts("Error - couldn't open input file");
  100.         seterror(54);
  101.         Exit(20);    /* Huh? where the hell is it? */
  102.     }
  103.     
  104.     /* Try to find the start string in the file. */
  105.     leng = strlen(sarg[3]);
  106.     while (fgets(line,256,infile))
  107.     {
  108.         if (stringcmp(line,sarg[3],&locate) == leng)
  109.         {
  110.             found++;
  111.             break;
  112.         }
  113.     }
  114.     
  115.     /* Did we find the string or run out of input file? */
  116.     if (!found)
  117.     {
  118.         puts("Could not find referenced text");
  119.         fclose(infile);
  120.         seterror(55);
  121.         Exit(20);  /* Ah well, can't have everything (anything?) */
  122.     }
  123.  
  124.     /* Ok, we found it, now try to open the output file */
  125.     if (!(outfile = fopen("ram:extract.txt","w")))
  126.     {
  127.         puts("Error - Couldn't open the output file");
  128.         fclose(infile);
  129.         seterror(56);
  130.         Exit(20);    /* bad news - something is seriously broke */
  131.     }
  132.     
  133.     /* Write the matching line to the output file, and commence copying */
  134.     fputs(line,outfile);
  135.     found = 0;
  136.     
  137.     /* if stop string is a ^L must read char by char mainly because */
  138.     /* I was too lazy to figure out a more efficient way to do it.  */
  139.     if (!stricmp(sarg[1],"^L"))
  140.     {
  141.         while ((inch = fgetc(infile)) != EOF)
  142.         {
  143.             if (inch == 0xC)
  144.             {
  145.                 found++;
  146.                 break;
  147.             }
  148.             fputc(inch,outfile);    /* we don't want to write the ^L */
  149.         }                            /* it makes reading difficult    */
  150.     }
  151.     else    /* otherwise read a line at a time */
  152.     {
  153.         leng = strlen(sarg[1]);
  154.         while (!found)
  155.         {
  156.             if (!(str = fgets(line,256,infile)))
  157.                 break;
  158.             if (stringcmp(str,sarg[1],&locate) == leng)
  159.                 found++;
  160.             fputs(line,outfile);
  161.         }
  162.     }
  163.  
  164.     /* we are (hopefully) done - either EOF or matched, go away anyway */
  165.     fclose(infile);
  166.     fclose(outfile);
  167.     return(0);     /* keep AREXX happy */
  168. }
  169.  
  170. /***    little bitty procedure to set the DOS return code if we have   ***/
  171. /***    an error.  If we just do an Exit(20) then ARexx doesn't know   ***/
  172. /***    anything about the error.                                       ***/
  173. int seterror(err)
  174. int err;
  175. {
  176.     HereWeAre->pr_Result2 = err;
  177.     return(0);
  178. }
  179.  
  180. /***********************************************************************
  181. *    stringcmp()
  182. *
  183. *    Unanchored non-destructive string comparison. Written primarily
  184. *    because I couldn't get the lattice pattern matching routines to
  185. *    work, and didn't feel like taking the time to figure out what was
  186. *    wrong.
  187. ***********************************************************************/
  188. int stringcmp(s,p,l)
  189. char *s,*p;
  190. int *l;
  191. {
  192.     int len1,len2,i;
  193.     
  194.     len1 = strlen(s);
  195.     len2 = strlen(p);
  196.  
  197.     /* this can't possibly match so give up immediately */
  198.     if (len1 < len2)
  199.         return(0);
  200.     
  201.     /* no need to go all the way to the end, just stop when target     */
  202.     /* can't fit in the remainder of the source                        */
  203.     for (i=0;i<len1-len2;i++)
  204.     {
  205.         if (!strncmp(s,p,len2))  /* I cheated a bit with this call */
  206.         {
  207.             *l = i;                /* want to know where in source we matched */
  208.             return(len2);
  209.         }
  210.         s++;
  211.     }
  212.     *l = len1;
  213.     return(0);    /* no match, sorry */
  214. }
  215.  
  216.  
  217. /**********************************************************************
  218. *    scopynull
  219. *
  220. *    This routine copies the first string to the second, skipping
  221. *    whitespace, except if it is enclosed in quotes 
  222. *    the procedure also places a null after each string section 
  223. *    (a string section is a contiguous group of printable ascii chars
  224. *    or several groups and whitespace inside quotes)
  225. *    and adds a null to the end of the resultant string (so that it ends
  226. *    with 2 nulls).  This is meant to be used primarily with the 
  227. *    Lattice function strbpl() which requires a string of this form 
  228. *    as input.
  229. **********************************************************************/
  230. void scopynull(s1,s2)
  231. char *s1,*s2;
  232. {
  233.     int inquote=0,copying=0;
  234.  
  235.     while (*s1)
  236.     {
  237.         if (*s1 == '\"')    /* is it a quote? yes -> just copy it */
  238.         {
  239.             s1++;
  240.             inquote = 1 - inquote;
  241.         }
  242.         if (inquote)        /* just copy it, like I said */
  243.         {
  244.             copying = 1;
  245.             *s2++ = *s1;
  246.         }
  247.         else
  248.         {
  249.             if (isspace(*s1) || (*s1 == '\n'))    /* whitespace or newline? */
  250.             {
  251.                 if (copying)    /* if we are in a string section, then       */
  252.                 {                /* we found the end of it, so put a NULL  */
  253.                     *s2++ = 0;    /* otherwise, just skip it                   */
  254.                     copying = 0;
  255.                 }
  256.             }
  257.             else
  258.             {
  259.                 copying = 1;    /* just copy the stupid thing already */
  260.                 *s2++ = *s1;
  261.             }
  262.         }
  263.         s1++;
  264.     }
  265.     *s2 = 0;
  266. }
  267.